Documentos CSV

Integrantes del grupo: David Rodríguez Calle, Gabriel Eduard Turtoi, Boyi Wang Chen, Antonio Ismael Cruz Tejada, Hector Triviño Landeira.

Archivos y Directorios¶

Acerca de los archivos:¶

  • Secuencia de bytes almacenados en un dipositivo.
  • La memoria RAM se encarga de editarlos y ejecutarlos al mommento. Este tipo de memorias son llamadas volátiles.
  • Su almacenamiento se lleva a cabo en memorias no volátiles (Discos duros, USB, CD-RW).
  • El uso de archivos se asemeja al de un cuaderno.

¿Cómo abrir nuestro primer archivo?¶

  • Si estamos trabajando con Python debemos de abrir nuestro llamado "handle".
  • Para abrir un archivo lo más sencillo es emplear la función "open".
In [1]:
f = open("workfile", "w", encoding = "utf-8")
f.close()
  • El modo "w" (write) hará que podamos escribir cada vez que iniciamos una nueva línea. La función ".close()" cerrará el archivo guardándose en el dispositivo.

Un ejemplo de código implementado en el modo "w":

In [2]:
f = open("test.text", "w")
f.write("Mi primer archivo escrito desde Python\n")
f.write("------------------------------------\n")
f.write("Hola, Mundo!\n")
f.close()

Sin embargo, en la práctica, se recomienda el uso de "with".

In [3]:
with open("workfile", encoding="utf-8") as f:
    read_data = f.read()

De esta manera se cierra automáticamente el archivo evitando que se pueda perder el código.

Tipos de modos:¶

El modo permite asignar al fichero la acción que se relizaría en él. Los principales tipos de modos son:

  • El modo "w" de escritura en el fichero. Presenta el inconveniente de recurrir a la función f.close().
  • El modo "r de lectura de ficheros.
  • El modo "a agrega nuevo contenido sin borrar el existente.
  • .
  • El modo "r+" permite la lectura y escritura simultánea.
  • Añadir "b" a cualquiera de los anteriores, permite que se use en modo binario.

Lectura de archivos:¶

En cuanto a la lectura de archivos, mediante el modo asignado "r" (read), un sencillo patrón como el siguiente, nos permitirá leer nuestro archivo:

In [4]:
mi_nuevo_archivo = open("C:/Users/Antonio/Desktop/test.txt", "r")

#Se mantiene leyendo siempre.
while True: 
    
    #Intenta leer la siguiente líena.
    linea = mi_nuevo_archivo.readline()
    
    #Si no hay más líneas abandona el bucle.
    if len(linea) == 0: 
        break
        
    #Ahora procesa la líena que acabamos de leer. 
    print(linea, end="")
    
mi_nuevo_archivo.close()
Este es un archivo de prueba

Hola M2

Archivo a listas de listas¶

Un caso particular del modo"r" sería el de uso de listas, permite agrupar las líneas de código en una sola lista.

In [5]:
f = open("C:/Users/Antonio/Desktop/amigos.txt", "r")
nombres = f.readlines()
f.close()
print(nombres)
nombres.sort()

nombres_ordenados = open("C:/Users/Antonio/Desktop/amigos_ordenados.txt", "w")
for line in nombres: 
    nombres_ordenados.write(line)
nombres_ordenados.close()
print(nombres_ordenados)
['Pedro\n', '\n', 'Alejandro\n', '\n', 'Boyi\n', '\n', 'Rodrigo\n', '\n', 'Manuel']
<_io.TextIOWrapper name='C:/Users/Antonio/Desktop/amigos_ordenados.txt' mode='w' encoding='cp1252'>

Leer todo el archivo a la vez¶

Otro método útil para la lectura de archivos es leer el contenido completo del archivo en una cadena, si no interesa la estructura de líenas.

Por ejemplo:

In [6]:
f = open("C:/Users/Antonio/Desktop/archio_ejemplo.txt")
contenido = f.read()
f.close()

palabras = contenido.split()

print("Hay {0} palabras en el archivo".format(len(palabras)))
Hay 0 palabras en el archivo

Directorios¶

  • Archivo superior que solo contiene información necesaria para acceder a otros archivos o directorios, ocupa menos espacio.
  • Estructura de los sistemas de archivos en forma de árbol invertido.

Img_5_Gabi_jupyter.png

  • Dirección decreciente desde el directorio de raíz.
  • Tipos de directorios:
    • /dev: Contiene archivos especiales para dispositivos de E/S.
    • /etc: Contiene archivos para la inicialización del sistema y la gestión del sistema.
    • /home: Contiene directorios de inicio de sesión para los usuarios del sitema.
    • /tmp: Contiene archivos que son temporales y que se suprimen automáticamnte después de un número especificado de días.
    • /usr: Contiene lpp, include y otros directorios del sistema.
    • /usr/bin:Contiene programas ejecutables de usuario.
  • Ruta de cada archivo
    • Un ejemplo de ruta en sistema operativo Windows:
    • "c:/temp/words.txt" o "c:\\temp\\words.txt"

  • Para el código:

archivo_de_palabras = open ( "/usr/share/dict/words" , "r" )

  • Acciones con directorios:
    • Creación: mandato mdkir mkdir Test
    • Mover, renombrar: mandato mvdir mvdir book3 proj4/manual
    • Cambiar directorio: mandato cd cd/usr/include
    • Copia: mandato cp cp -R/home/accounts/customers /home/accounts/vendors

¿Qué es un archivo CSV?

Las siglas CSV vienen del inglés "Command Separated Values" y significan valores separadas por comas. De esta manera un archivo CSV es cualquier archivo de texto en el que los caracteres están separados por comas, haciendo una tabla de filas y columnas. Las filas se definen por una línea adicional en el texto y las columnas por cada punto y coma (;).

Dependiendo de la región en la que estemos trabajando se utilizará una notación u otras, en países anglosajones se uitilizan las comas (,) para separar los elementos, mientras que en países europeas se utilizan los puntos y coma (;).

Una de las ventajas de los archivos .CSV es la facilidad con la que se pueden almacenar datos y el poco espacio de almacenamiento que ocupan. Normalmente se asocian este tipo de archivos con Excel, ya que es la forma más común de leer estos archivos, sin embargo excel no siempre es capaz de leer este tipo de archivos.

¿Para qué sirve un archivo CSV?

Los archivos .csv nos ayudan a manejar grandes cantidades de datos en un formato tipo tabla de un forma sencilla y sin que eso conlleve un sobrecosto computacional innecesario. La creación de una tabla es tan sencilla como abrir un bloc de notas vacío, escribir dos caracteres separados por una coma, los cuales funcionaran como cabeceras de las columnas, y después escribir los caracteres que se deseen debajo de las columnas que les corrsponda. Normalmente el siguiente paso es convertir ese csv a Excel.

En caso de que necesites usar un separador como parte del contenido de una celda, tendrás que usar comillas para abarcar tantos caracteres como quieras en dicha celda, así Excel lo identificará como un solo bloque y le asignará una única celda.

La parte "mala" de esto es que los archivos CSV tan solo admiten datos "en crudo", es decir, no podremos seleccionar colores ni formatos de tabla que queramos visualizar una vez lo abramos con Excel, por ejemplo. Estas propiedades son ajenas al documento y son tratadas desde el programa con el que abramos el archivo CSV.

¿Cómo abrir correctamente un archivo .csv en Excel ?

1. Abrir Excel para crear un nuevo libro.

Img_1_B_Jupyter.jpg

2. Ir a la pestaña de "Datos" y hacer clic sobre "De texto/CSV".

Img_2_B_Jupyter.jpg

3. Se abirá la ventana del explorador de archivos y buscar el archivos CSV que se desee abrir.

Img_3_B_Jupyter.jpg

4. Se abrirá un asistente para ayudar con la importación del archivo. Excel detecta el origen y delimitador de forma automática, si todo está bien se pulsará el botón de "Cargar".

Img_4_B_Jupyter.jpg

5. Se abrirá el archivo CSV correctamente.

Img_5_B_Jupyter.jpg

¿Cómo convertir un archivo .csv a Excel?

1. Abrimos un nuevo fichero Excel.

Img_1_Jupyter.jpeg

2.Clicamos en archivo-abrir-examinar, y se nos abre el explorador donde seleccionamos nuestro archivo CSV, y clicamos en abrir.

Img_2_Jupyter.jpeg

3. Se nos abre el sistema para importar texto, donde marcamos en tipo de datos originales que los datos están delimitados (en este caso por ";"), y marcamos la fila a partir de la que queremos importar desde la fila 1 que aparecerá por defecto, y clicamos en siguiente.

Img_3_Jupyter.jpeg

4. La siguiente pantalla del asistente nos aparecen los posibles separadores del fichero CSV, por defecto aparece marcado la trabulación pero en nuestro caso tendremos que marcar ";", y clicamos en siguiente.

Img_4_Jupyter.jpeg

5. En la última pantalla del asistente seleccionamos el formato de los datos en las columnas, en nuestro caso las 3 columnas que tenemos, el tipo de datos es general. Después de haber seleccionado el formato para las diferentes columnas y clicamos finalizar.

Img_5_Jupyter.jpeg

6. Al clicar finalizar nos aparecen los datos del fichero CSV formateados en nuestro Excel.

Img_6_Jupyter.jpeg

Otro método para convertir un fichero CSV a formato Excel, sería el siguiente:<h/2>

1. Abrir una hoja en blanco en Excel.

Img_7_Jupyter.jpeg

2. Después se nos abrirá una nueva ventana que previsualiza el formato que tendrán los datos según las opciones seleccionadas. Aquí podemos elegir el "delimitador CSV" o bien seleccionar uno propio. La vista previa se actualiza a cada cambio que hacemos, por lo que es instantáneo. Es importante notar que, a pesar de que nuestros valores tenían decimales en forma de punto, aquí no se muestran así, no pasa nada porque lo arreglamos más adelante con un simple clic.

Img_8_Jupyter.jpeg

3. Cuando veamos que el formato que queremos, le damos a "Transformar datos" y tardará unos segundos en crearse (en función del ordenador y de la longitud del archivo CSV). Luego nos llevará a una ventana final donde ya se muestran los datos distribuidos en una tabla. Ahora es cuando a la derecha, en Pasos aplicados, podemos clicar sobre clicar sobre la cruz que dice Tipo cambiado.

Img_9_Jupyter.jpeg

4. Si ahora le damois a "Cerrar" y cargar nos llevará a un libro de Excel con los datos tal y como los teníamos mediante el otro método, por lo que son caminos equivalentes para convertir un archivo CSV en Excel.

Img_10_Jupyter.jpeg

Finalmente quedaría así:

Img_11_Jupyter.jpeg

¿Con qué módulo podemos usar archivos CSV en Pyhton?

En python tenemos incorporado el módulo CSV que implementa clases que leen y escriben datos de tablas principalmente en formato CSV. Este módulo permite a los programadores guardar mucha información en un formato que ocupa poco espacio y que funciona muy bien con Excel o poder leer datos de un archivo generado por Excel sin conocer los detalles precisos del formato CSV utilizado por Excel.

Este módulo tiene como predeterminado tres "dialectos" que son los formatos que es capaz de leer y escribir, aunque nostros podremos crear nuestros propios formatos personalizados o importarlos. Los tres predeterminados son Excel, Excel-tab y unix, nosotros principalmente usaremos el formato excel.

Las funciones más útiles que nos proporciona este módula son las siguientes:

In [7]:
import csv

  • csv.writer : Con esta función podremos escribir en archivos CSV.

    • Sintaxis: csv.writer(csvfile, dialect=’excel’, **fmtparams)

    Los parametros de la función son:


    • csvfile: un archivo con el metodo write()

    • dialect (opcional): Nombre del dialecto que se va a usar
    • fmtparams (opcional): Parámetros que se quieren conservar que serían eliminados por el dialecto escogido.

    Dentro de esta funcíon tenemos los métodos: writerow() y writerows()


    • writerow(): Este método escribe una única línea a la vez, es útil para escribir las cabeceras de las columnas.

      • Sintaxis: writerow()

      </ul>

      • writerows: Este método escribe varias líneas a la vez. Esto nos es útil para escribir una lista de líneas.
        • Sintaxis: writerows(ejemploporponer)
In [8]:
#Cabeceras
cabeceras = ['Nombre', "Asignatura", "Grupo", "Nota"]

#Filas del archivos CSV
filas = [["Antonio", "TAE", "M2", 5.0],
         ["Paula", "Matemáticas I", "M1", 4.7],
         ["Ana", "Física I", "M5", 9.0],
         ["José Luis", "Informática", "M3", 6.2]]
#Nombre del archivo CSV
filename = "notas_ordinarios.csv"

#Escritura como CSV

with open(filename, "w") as csvfile:
    #creando un objeto de escritura nuevo del tipo csv
    csvwriter = csv.writer(csvfile)
    
    #escribiendo las cabeceras
    csvwriter.writerow(cabeceras)
    
    #escribiendo los datos
    csvwriter.writerows(filas)
    
    print(csvfile)
<_io.TextIOWrapper name='notas_ordinarios.csv' mode='w' encoding='cp1252'>

  • csv.DictWriter: Esta función nos devolverá un objeto con formato de diccionario como una serie de filas en función de los cabeceros o "campos" a los que pertenezca el elemento.
    • Sintaxis: csv.DictWriter(csvfile, fieldnames, restval=”, extrasaction=’raise’, dialect=’excel’, *args, **kwds)

    Los parámetros de la función son:


    • csvfile: Un objeto tipo archivo con el método write().
    • fieldnames: Una secuencia de palabrs claves que determinan el orden en el que los elementos del diccionario deben de mostrarse.
    • restval (opcional): Especifica el valor que se debe escribir si al diccionario le hace falta alguna palabra clave.
    • extrasaction (opcional): Si una palabra clave no se encuentra dentro de las cabeceras, esta parámetro de extracción indicará que acciíon se debe tomar.
    • dialect (opcional): Nombre del dialecto que se va a usar.

    csv.DictWriter nos proprciona dos métodos para escribir en CSV:


    • writeheader(): Escribe la primera fila de nuestro archivo, la cual será los cabeceros que nostros queramos.
      • Sintaxis: writeheader()
    • writerows(): Escribe tdoas las filas pero en cada fila solo escribe los valores, no los cabeceros asignados a estos.
      • Sintaxis: writerows(mydict)
In [9]:
# importing the csv module
import csv

# my data rows as dictionary objects
midiccionario =[{'Asignatura': 'TAE', 'Nota': 9.0, 'Nombre': 'Javier', 'Grupo': 'M2'},
                {'Asignatura': 'Física I', 'Nota': 9.1, 'Nombre': 'Pedro', 'Grupo': 'T2'},
                {'Asignatura': 'Matemáticas I', 'Nota': 9.3, 'Nombre': 'David', 'Grupo': 'T2'},
                {'Asignatura': 'Informática', 'Nota': 9.5, 'Nombre': 'Magdalena', 'Grupo': 'M1'},
                {'Asignatura': 'TAE', 'Nota': 7.8, 'Nombre': 'María José', 'Grupo': 'M3'},
                {'Asignatura': 'Química', 'Nota': 9.1, 'Nombre': 'Héctor', 'Grupo': 'M2'}]

# field names
cabeceras = ['Nombre', 'Asignatura', 'Grupo', 'Nota']
    
# name of csv file
filename = "Notas_ordinarios_V2.csv"
    
# writing to csv file
with open(filename, 'w') as csvfile:
    # creando un arhcivo csv de tipo diccionario
    writer = csv.DictWriter(csvfile, fieldnames = cabeceras)
        
    # escritura de las cabeceras
    writer.writeheader()
        
    # escritura de los datos en las filas
    writer.writerows(midiccionario)

  • csv.reader: Con esta función podremos leer los datos del archivo que queramos.
    • Sintaxis: csv.reader(csvfile, dialect=’excel’, quoting)

    Los parametros de la función son:


    • csvfile: objeto iterable que nos permita extraer elementos de él.
    • Dialect (opcional): Nombre del dialecto que se va a usar.
    • Quoting (opcional): Forma en la que queremos que trate a los elementos del archivo según su tipo.
    • Dependiendo el tipo de quoting que usemos nos devolverá los datos de una forma u otra.

      Las distintos tipos de quoting que tenemos son:


      • csv.QUOTE_MINIMAL: Es el quoting por defecto y nos devuelvo todos los elemento como string, indepenedientemente de si son números o caracters.

      • csv.QUOTE_NONNUMERIC: Transformará a float todo lo que no este entrecomillado, si en el archivo tenemos un caracter no entrecomillado que no se pueda pasar a float, nos dará un error.

      • csv.QUOTE_NONE: Entrecomillará todo y mantendrá las comillas originales.
In [10]:
with open("./notas_ordinarios.csv", newline="\r\n") as csvfile:
    reader = csv.reader(csvfile, delimiter=",",)
    for row in reader:
        print(row)
['Nombre', 'Asignatura', 'Grupo', 'Nota']
['Antonio', 'TAE', 'M2', '5.0']
['Paula', 'Matemáticas I', 'M1', '4.7']
['Ana', 'Física I', 'M5', '9.0']
['José Luis', 'Informática', 'M3', '6.2']

  • csv.DictReader: Esta función nos permitirá leer las fila como un diccionario usando el cabecero como clave.
    • Sintaxis:csv.DictWriter(csvfile, fieldnames, restval=”, extrasaction=’raise’, dialect=’excel’, *args, **kwds)

    Los parámetros de la función son:


    • csvfile: Un objeto tipo archivo con el método write().
    • fieldnames: Una secuencia de palabrs claves que determinan el orden en el que los elementos del diccionario deben de mostrarse.
    • restval (opcional): Especifica el valor que se debe escribir si al diccionario le hace falta alguna palabra clave.
    • extrasaction (opcional): Si una palabra clave no se encuentra dentro de las cabeceras, esta parámetro de extracción indicará que acciíon se debe tomar.
    • dialect (opcional): Nombre del dialecto que se va a usar.
In [11]:
with open("./Notas_ordinarios_V2.csv", newline="") as csvfile:
    reader = csv.DictReader(csvfile, delimiter=",", quoting=csv.QUOTE_NONE)
    for row in reader:
        print(row)
        print(row['Nombre'])
{'Nombre': 'Javier', 'Asignatura': 'TAE', 'Grupo': 'M2', 'Nota': '9.0'}
Javier
{'Nombre': 'Pedro', 'Asignatura': 'Física I', 'Grupo': 'T2', 'Nota': '9.1'}
Pedro
{'Nombre': 'David', 'Asignatura': 'Matemáticas I', 'Grupo': 'T2', 'Nota': '9.3'}
David
{'Nombre': 'Magdalena', 'Asignatura': 'Informática', 'Grupo': 'M1', 'Nota': '9.5'}
Magdalena
{'Nombre': 'María José', 'Asignatura': 'TAE', 'Grupo': 'M3', 'Nota': '7.8'}
María José
{'Nombre': 'Héctor', 'Asignatura': 'Química', 'Grupo': 'M2', 'Nota': '9.1'}
Héctor

Representación de funciones en matplotlib a partir de archivos CSV

Importación de los módulos que van a ser empleados:

Numpy: Para utilizar matrices en el cálculo de los puntos de las funciones.

Matplotlib: Para representar las funciones, haciendo uso de contornos y herramientas para representar funciones de dos variables en 3D.

Csv: Para escribir y leer archivos .csv de una forma más simple que si estos se trataran como ficheros.

In [12]:
import numpy as np 
import matplotlib.pyplot as plt
import csv 

Definición de tres funciones, dos de ellas de una variable, y otra de dos:

  • f_x1: Es un polinomio de grado 10 que, mediante mínimos cuadrados, se aproxima a los valores del coeficiente de presiones obtenidos sobre un cilindro en un túnel aerodinámico.

$-0.0544339494*x^{10} + 0.7877499213*x^{9}- 4.5754539125*x^{8} + 12.9373935548*x^{7}- 14.6038654707*x^{6}- 11.8402960283*x^{5} + 52.4289810264*x^{4} - 53.9857029054*x^{3} + 19.5695202645*x^{2} - 3.130686006*x + 1.0861351645$

  • f_x2: Devuelve los valores de la distribución teórica de un coeficiente de presiones en un cilindro sin fuerzas viscosas, dados por la función:

$1 - 4sin(x)^2$

  • f_xy: Emplea funciones trigonométricas para crear una superficie muy accidentada, y que permite mostrar adecuadamente la utilización de contornos para rerpesentarla.
  • $e\tfrac{sin(x) * cos(y*x)^{2} + cos(y)}{\pi }$

    In [13]:
    def f_x1(x):
        """Polinomio de grado 10 que se aprozima a los valores del coeficiente de presiones de un cilindro
        obtenidos experimentalmente"""
        return -0.0544339494 * x ** 10 + 0.7877499216 * x ** 9 - 4.5754539125 * x ** 8 + 12.9373935548 * x ** 7 - 14.6038654707 * x ** 6 - 11.8402960283 * x ** 5 + 52.4289810264 * x ** 4 - 53.9857029054 * x ** 3 + 19.5695202645 * x ** 2 - 3.130686006 * x + 1.0861351645
    
    
    def f_x2(x):          
        """Distribución teórica del coeficiente de presiones en un cilindro, sin considerar los esfuerzos viscosos."""
        return 1 - 4 * np.sin(x) ** 2
    
    
    def f_xy(x, y):
        """Función de dos variables con senos y cosenos"""
        return (np.sin(x)*np.cos(y * x)**2 + np.cos(y))/(np.pi/np.e)
    

    Escritura de un primer archivo csv, con las funciones de una variable:

    En la primera línea, se abre un archivo csv, en el modo de escritura. Después llamamos a la función csv.writer para crear un objeto que nos permita editar archivos .csv de forma fácil. Tras hacer esto y crear un vector con los valores de x que se van a emplear para calcular las funciones dentro del intervalor deseado, se escribe en cada fila del archivo el valor de x y los valores de f1(x) y f2(x) que le corresponden.

    In [14]:
    with open("Datos_fx.csv", "w", newline='\r\n') as entrada1:
        csvwriter = csv.writer(entrada1, dialect='excel')  # Creación de un "writer"
        x = np.linspace(0, np.pi, 100)                     # x es un vector con 100 elementos equiespaciados entre 0 y pi
        cabecera = ["x", "f1(x)", "f2(x)"]
        csvwriter.writerow(cabecera)                       # Insertar la cabecera del archivo 
        for i in x:                             # Recorrer todos los valores de x para los que se va a estudiar la función
            row = [i, f_x1(i), f_x2(i)]         # Disponer en una fila el valor de x, y sus correspondientes imágenes 
            csvwriter.writerow(row)
    

    Lectura del archivo csv con las funciones de una variable:

    Partiendo del archivo csv con los datos necesarios para representar las dos funciones, se abre este en modo de lectura y se crea un objeto para leerlo con la función csv.reader. Se almacenarán en vectores los valores obtenidos en cada línea según estos se van leyendo del archivo y, después de haberlo leído por completo y cerrar el archivo. Se graficarán las dos funciones con la función plot.

    In [15]:
    with open("Datos_fx.csv", "r", newline='\r\n') as salida1:
        reader = csv.reader(salida1, dialect='excel')
        next(reader)
        x = np.array([])            # Se inicializan tres vectores vacíos, para alojar los valores de
        fx1 = np.array([])          # x, f1 y f2 del archivo 
        fx2 = np.array([])                                           # Se usa la función next() para saltar la línea del encabezado
        for line in reader: 
    #        next(reader)                       # Se recorren todas las líneas restantes del archivo de una en una,
                                               # añadiendo cada elemento al vector que le corresponde
            x = np.append(x, float(line[0]))
            fx1 = np.append(fx1, float(line[1]))
            fx2 = np.append(fx2, float(line[2]))
    
    plt.plot(x, fx1)    #Representar la primera función
    plt.plot(x, fx2)    #Representar la segunda función
    
    Out[15]:
    [<matplotlib.lines.Line2D at 0x1d0d59ebaf0>]

    Escritura de un archivo csv con los valores de una función de dos variables:

    Al igual que para escribir el archivo anterior, se siguen los pasos hasta crear un 'writer' para un nuevo archivo. Empleamos la función meshgrid sobre dos vectores x e y de longitud n (que contienen todos los valores de x e y de que va a tomar la función) para obtener matrices de n * n que permitan la aplicación directa de la función f_xy para obtener una matriz Z que contenga todos los resultados calculados. Una vez se tienen las matrices X, Y y Z, se recorren estas, escribiendo en una misma fila los valores de las tres matrices que se encuentran en la misma posición.

    Explicación del funcionamiento de la función meshgrid

    Al recibir dos matrices de dimensión uno y tamaños m y n, devolverá dos matrices de dimensión dos y tamaño m*n, en las cuales se ha asociado el primer vector a la dirección horizontal, y el segundo a la vertical.

    $x = \begin{bmatrix} x_{1} & x_{2} & \cdots & x_{m} \end{bmatrix}$

    $y = \begin{bmatrix} y_{1} & y_{2} & \cdots & y_{n} \end{bmatrix}$

    xx, yy = np.meshgrid(x, y)

    $xx = \begin{bmatrix} x_{1}(1) & x_{2}(1) & \cdots & x_{m}(1)\\ x_{1}(2) & x_{2}(2) & \cdots & x_{m}(2)\\ \vdots & \vdots & \ddots & \vdots \\ x_{1}(n) & x_{2}(n) & \cdots & x_{m}(n)\\ \end{bmatrix}$

    $yy = \begin{bmatrix} y_{1}(1) & x_{1}(2) & \cdots & x_{1}(m)\\ y_{2}(1) & x_{2}(2) & \cdots & x_{2}(m)\\ \vdots & \vdots & \ddots & \vdots \\ y_{n}(1) & x_{n}(2) & \cdots & x_{n}(m)\\ \end{bmatrix}$

    Ejemplo práctico:

    $x = \begin{bmatrix} 1 & 2 & 3 & 4 & 5 \end{bmatrix}$

    $y = \begin{bmatrix} 0 & 0.5 & 1 \end{bmatrix}$

    $xx = \begin{bmatrix} 1 & 2 & 3 & 4 & 5\\ 1 & 2 & 3 & 4 & 5\\ 1 & 2 & 3 & 4 & 5 \end{bmatrix}$

    $yy = \begin{bmatrix} 0 & 0 & 0 & 0 & 0\\ 0.5 & 0.5 & 0.5 & 0.5 & 0.5 \\ 1 & 1 & 1 & 1 & 1 \end{bmatrix}$

    In [16]:
    with open("Datos_fxy.csv", "w") as entrada2:
        csvwriter = csv.writer(entrada2, dialect='excel')
        x = np.linspace(-5, 5, 500)         # Se crean dos vectores con 500 valores equiespaciados entre -5 y 5
        y = np.linspace(-5, 5, 500)
        X, Y = np.meshgrid(x,y)  # Utilizando meshgrid, se obtienden dos matrices X e Y, de 2 dimensiones
        Z = f_xy(X, Y)           # Z es resultado de aplicar la función f_xy a los elementos de X e Y de la misma posición
        cabecera = ["x", "y", "f(x,y)"]
        csvwriter.writerow(cabecera)        # Escritura de un cabecero en el archivo           
        for i in range(np.shape(Z)[0]):     # Para recorrer todas las filas de las matrices, se da como argumento a range
                                            # el número de filas de Z (que sería el mismo para X e Y)
            for j in range(np.shape(Z)[1]):          # Se da el mismo caso que en la línea anterior, para recorrer 
                                                     # las columnas de X, Y y Z
                row = [X[i,j], Y[i,j], Z[i, j]]             # Se escribe en una fila el valor de X, Y y Z correspondiente
                csvwriter.writerow(row)                     # a una misma posición
    

    Lectura del archivo csv para una función de dos variables

    Siguiendo los pasos realizados antes para crear un objeto de tipo 'reader', se recorren las filas del archivo una a una y se guardan ordenamente los datos en tres lista X, Y y Z. Estas listas se reducen a una sola dimensión (a diferencia de las matrices a partir de las cuales se escribió el archivo), pero si se tiene en cuenta el orden seguido al guardar los datos en el archivo (escribiendo los datos de cada fila de las matrices por completo antes de pasar a la siguiente) se pueden transformar las listas X, Y, Z actuales en matrices que sean iguales a las originales mediante el uso de la función reshape, que dividirá las listas de 2500 elementos en 500 filas de 500 elementos cada una.

    In [17]:
    with open("Datos_fxy.csv", "r") as salida2:
        reader = csv.reader(salida2, delimiter = ',')
        next(reader)
        next(reader)               #Saltar línea del encabezado
        X, Y, Z = [], [], []           #Se inicializan tres listas vacías, para alojar los valores de x, y, z de cada fila
        for line in reader:
            next(reader)               #Recorrer todas las filas restantes del archivo
            X.append(float(line[0]))
            Y.append(float(line[1]))
            Z.append(float(line[2]))
            
    
    X = np.array(X).reshape((500,500)) # Modificar la forma del vector y convertirlo en un array de dimensión 2,
    Y = np.array(Y).reshape((500,500)) # recuperando así su forma original antes de ser escrito en el archivo csv
    Z = np.array(Z).reshape((500,500))
    

    Representación de la función de dos variables

    1. Contornos

    Para ofrecer una representación detallada de la función en dos dimensiones, se emplean contornos y un mapa de colores para ilustrar las zonas de la función con valores mayores y menores. Los contornos diferencian los valores positivos y negativos mediante líneas continuas (valores positivos) y de trazos (valores negativos).

    In [18]:
    contours = plt.contour(X, Y, Z, 5,                      # Se crean 5 niveles para mostrar las líneas de contorno de
                           colors='black', alpha = 0.8)     # la superficie, de color negro y una transparencia de 0.8
    
    plt.clabel(contours, inline=True, fontsize=8)           # El valor de z para cada nivel se mostrará en la línea del
                                                            # contorno, y el tamaño de las letras será 8
        
    plt.imshow(Z, extent=[-5, 5, -5, 5], origin='lower',    # Se muestra el mapa de colores de la función, dándole también
               cmap='jet', alpha=0.8)                       # una transparencia de 0.8
    
    plt.colorbar()                                          # Añadir una barra a la izquierda que sirva de leyenda 
                                                            # para ayudar a comprender el mapa de colores
    
    Out[18]:
    <matplotlib.colorbar.Colorbar at 0x1d0d5a9e220>

    2. Representación en 3D

    Con el objetivo de facilitar la visualización de la función, esta también se ha representado en un espacio de 3 dimensiones, utilizando el mismo mapa de colores que en la sección anterior.

    In [19]:
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='jet')
    plt.show()